// 全局变量
let currentApiDoc = null;
let navCategories = []; // 存储所有导航数据
let currentModule = null;
let currentGroup = null;

// 初始化
$(document).ready(() => {
    // 等待外部库加载完成
    waitForLibraries(() => {
        loadNavigation();
    });
});

// 等待外部库加载
function waitForLibraries(callback) {
    let attempts = 0;
    const maxAttempts = 50; // 最多等待5秒
    
    const checkLibraries = () => {
        if (typeof marked !== 'undefined' && typeof hljs !== 'undefined') {
            callback();
        } else if (attempts < maxAttempts) {
            attempts++;
            setTimeout(checkLibraries, 100);
        } else {
            console.warn('外部库加载超时，使用降级模式');
            callback();
        }
    };
    
    checkLibraries();
}

// 加载导航
async function loadNavigation(forceRefresh = false) {
    try {
        // 始终添加时间戳和缓存控制以强制清除缓存
        const url = `./summary.md?t=${Date.now()}`;
        const options = { cache: 'no-cache' };
        
        const response = await fetch(url, options);
        const text = await response.text();
        navCategories = parseSummary(text);
        renderModuleSelect();
    } catch (error) {
        console.error('加载导航失败:', error);
        $('#navTree').html('<div class="api-list-empty">加载导航失败</div>');
    }
}

// 刷新导航
function refreshNavigation() {
    // 重新加载页面并添加时间戳参数以强制清除缓存
    const currentUrl = window.location.href.split('?')[0];
    window.location.href = currentUrl + '?t=' + Date.now();
}

// 渲染模块选择框
function renderModuleSelect() {
    const $moduleSelect = $('#moduleSelect');
    $moduleSelect.html('<option value="">请选择模块...</option>');
    
    navCategories.forEach((category, index) => {
        $moduleSelect.append($('<option>', {
            value: index,
            text: category.name
        }));
    });

    // 重置组别选择和接口列表
    $('#groupSelect').html('<option value="">请先选择模块...</option>');
    $('#navTree').html('<div class="api-list-empty">请先选择模块和组别</div>');
}

// 模块选择变化
function onModuleChange() {
    const moduleIndex = $('#moduleSelect').val();
    
    if (moduleIndex === '') {
        $('#groupSelect').html('<option value="">请先选择模块...</option>');
        $('#navTree').html('<div class="api-list-empty">请先选择模块和组别</div>');
        currentModule = null;
        return;
    }
    
    currentModule = navCategories[moduleIndex];
    renderGroupSelect();
}

// 渲染组别选择框
function renderGroupSelect() {
    const $groupSelect = $('#groupSelect');
    $groupSelect.html('<option value="">请选择组别...</option>');
    
    if (!currentModule) return;
    
    currentModule.groups.forEach((group, index) => {
        $groupSelect.append($('<option>', {
            value: index,
            text: group.name
        }));
    });

    // 重置接口列表
    $('#navTree').html('<div class="api-list-empty">请选择组别</div>');
}

// 组别选择变化
function onGroupChange() {
    const groupIndex = $('#groupSelect').val();
    
    if (groupIndex === '' || !currentModule) {
        $('#navTree').html('<div class="api-list-empty">请选择组别</div>');
        currentGroup = null;
        return;
    }
    
    currentGroup = currentModule.groups[groupIndex];
    renderApiList();
}

// 渲染接口列表
function renderApiList() {
    const $navTree = $('#navTree');
    
    if (!currentGroup || !currentGroup.items || currentGroup.items.length === 0) {
        $navTree.html('<div class="api-list-empty">该组别暂无接口</div>');
        return;
    }
    
    const $list = $('<ul>', { class: 'api-list' });
    currentGroup.items.forEach(item => {
        const $li = $('<li>', {
            class: 'api-list-item',
            'data-file': item.file,
            'data-anchor': item.anchor,
            text: item.name,
            click: function() {
                loadApiDoc(item.file, item.anchor);
            }
        });
        $list.append($li);
    });
    
    $navTree.html($list);
}

// 解析 summary.md
function parseSummary(text) {
    const lines = text.split('\n');
    const categories = [];
    let currentCategory = null;
    let currentGroup = null;

    for (const line of lines) {
        // 匹配分类 ## 采购模块 (Procurement)
        const categoryMatch = line.match(/^##\s+(.+?)\s+\((.+?)\)/);
        if (categoryMatch) {
            currentCategory = {
                name: categoryMatch[1],
                nameEn: categoryMatch[2].toLowerCase(),
                groups: []
            };
            categories.push(currentCategory);
            continue;
        }

        // 匹配分组 ### 结算单管理 (Settlement)
        const groupMatch = line.match(/^###\s+(.+?)\s+\((.+?)\)/);
        if (groupMatch && currentCategory) {
            currentGroup = {
                name: groupMatch[1],
                nameEn: groupMatch[2].toLowerCase(),
                items: []
            };
            currentCategory.groups.push(currentGroup);
            continue;
        }

        // 匹配接口项 - [创建结算单](./procurement/settlement.md#创建结算单)
        const itemMatch = line.match(/^-\s+\[(.+?)\]\(\.\/(.+?)#(.+?)\)/);
        if (itemMatch && currentGroup) {
            currentGroup.items.push({
                name: itemMatch[1],
                file: itemMatch[2],
                anchor: itemMatch[3]
            });
        }
    }

    return categories;
}

// 加载 API 文档
async function loadApiDoc(file, anchor) {
    try {
        // 更新导航选中状态
        $('.api-list-item').removeClass('active');
        $(event.currentTarget).addClass('active');

        // 加载文档，添加时间戳参数和缓存控制以强制清除缓存
        const response = await fetch(`./${file}?t=${Date.now()}`, { cache: 'no-cache' });
        const text = await response.text();
        
        // 解析文档，提取指定的接口
        let apiDoc = extractApiDoc(text, anchor);
        
        // 如果提取失败，尝试使用备用方法
        if (!apiDoc) {
            console.warn(`标准方法无法提取接口文档，尝试备用方法: ${anchor}`);
            // extractApiDoc 内部已经调用了 extractApiDocByRegex，如果还是失败，说明真的找不到
            // 这种情况下，我们仍然需要显示错误信息，而不是显示整个文档
            console.error(`无法提取接口文档，anchor: "${anchor}"`);
            const $emptyState = $('#dotboxBody .empty-state .empty-state-text');
            if ($emptyState.length) {
                $emptyState.text(`无法找到接口文档: ${anchor}`);
            }
            $('#dotboxBody').removeClass('has-content');
            return;
        }
        
        // 保存提取的文档
        currentApiDoc = apiDoc;
        
        // 渲染文档，传递文件路径和 anchor
        renderApiDoc(apiDoc, file, anchor);
    } catch (error) {
        console.error('加载文档失败:', error);
        const $emptyState = $('#dotboxBody .empty-state .empty-state-text');
        if ($emptyState.length) {
            $emptyState.text(`加载文档失败: ${error.message}`);
        }
        // 移除 has-content 类，显示占位元素
        $('#dotboxBody').removeClass('has-content');
    }
}

// 从 Markdown 中提取指定的接口文档（备用方法，使用正则表达式直接匹配）
function extractApiDocByRegex(text, anchor) {
    if (!anchor || !text) {
        return null;
    }
    
    const normalizedAnchor = anchor.trim();
    // 转义特殊字符，用于正则表达式
    const escapedAnchor = normalizedAnchor.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
    
    // 尝试多种匹配模式
    const patterns = [
        // 精确匹配：## 标题（行首，后面可能有空格和换行）
        new RegExp(`^##\\s+${escapedAnchor}\\s*$`, 'm'),
        // 容错匹配：允许标题中的空格变化
        new RegExp(`^##\\s+${escapedAnchor.replace(/\s+/g, '\\s+')}\\s*$`, 'm'),
    ];
    
    for (const pattern of patterns) {
        const match = text.match(pattern);
        if (match) {
            const matchIndex = match.index;
            const matchLength = match[0].length;
            
            // 从匹配位置开始，提取到下一个 ## 或文档结尾
            const startPos = matchIndex;
            const afterTitle = text.substring(startPos + matchLength);
            
            // 查找下一个 ## 标题的位置
            const nextSectionMatch = afterTitle.match(/^##\s+/m);
            
            let sectionContent;
            if (nextSectionMatch) {
                // 找到下一个 section，提取到该位置之前
                const nextIndex = afterTitle.indexOf(nextSectionMatch[0]);
                sectionContent = afterTitle.substring(0, nextIndex).trim();
            } else {
                // 没有下一个 section，提取到文档结尾
                sectionContent = afterTitle.trim();
            }
            
            // 返回完整的 section（包括标题）
            return '## ' + normalizedAnchor + '\n\n' + sectionContent;
        }
    }
    
    return null;
}

// 从 Markdown 中提取指定的接口文档
function extractApiDoc(text, anchor) {
    if (!anchor || !text) {
        return null;
    }
    
    // 规范化 anchor：去除首尾空格
    const normalizedAnchor = anchor.trim();
    
    // 使用正则表达式分割，保留分隔符信息
    const sections = text.split(/^##\s+/m);
    
    // 调试信息：记录所有找到的标题
    const foundTitles = [];
    
    // 跳过第一个 section（文档开头部分，可能包含一级标题等）
    for (let i = 1; i < sections.length; i++) {
        const section = sections[i].trim();
        if (!section) continue;
        
        // 获取第一行作为标题（去除空行）
        const lines = section.split('\n');
        let title = '';
        for (let j = 0; j < lines.length; j++) {
            const line = lines[j].trim();
            if (line) {
                title = line;
                break;
            }
        }
        
        if (!title) continue;
        
        // 记录找到的标题（用于调试）
        foundTitles.push(title);
        
        // 精确匹配
        if (title === normalizedAnchor) {
            console.log(`成功匹配接口文档，anchor: "${normalizedAnchor}", title: "${title}"`);
            return '## ' + section;
        }
        
        // 容错匹配：去除所有空格后比较（处理可能的空格差异）
        const titleNoSpaces = title.replace(/\s+/g, '');
        const anchorNoSpaces = normalizedAnchor.replace(/\s+/g, '');
        if (titleNoSpaces === anchorNoSpaces) {
            console.log(`成功匹配接口文档（容错匹配），anchor: "${normalizedAnchor}", title: "${title}"`);
            return '## ' + section;
        }
    }
    
    // 如果没找到，尝试使用正则表达式方法
    console.warn(`标准方法未找到匹配的接口文档，尝试备用方法，anchor: "${normalizedAnchor}"`);
    console.warn(`文档中找到的标题列表:`, foundTitles);
    
    const regexResult = extractApiDocByRegex(text, anchor);
    if (regexResult) {
        console.log(`备用方法成功匹配接口文档，anchor: "${normalizedAnchor}"`);
        return regexResult;
    }
    
    return null;
}

// 渲染 API 文档
function renderApiDoc(markdown, filePath, anchor) {
    // 如果 marked 库未加载，使用简单的文本渲染
    if (typeof marked === 'undefined') {
        $('.api-file-path').text('文档路径: 未知');
        $('.api-description').text('Markdown 解析库未加载');
        $('#dotboxBody').addClass('has-content');
        return;
    }
    
    // 解析 markdown 为 HTML
    const html = marked.parse(markdown);
    const $temp = $('<div>').html(html);
    
    // 提取并更新标题
    let title = '';
    const $h2Elements = $temp.find('h2');
    
    // 如果只有一个 h2，说明提取成功，直接使用
    if ($h2Elements.length === 1) {
        title = $h2Elements.first().text();
    } 
    // 如果有多个 h2，说明可能是整个文档，尝试根据 anchor 查找匹配的标题
    else if ($h2Elements.length > 1 && anchor) {
        const normalizedAnchor = anchor.trim();
        let found = false;
        
        $h2Elements.each(function() {
            const h2Text = $(this).text().trim();
            // 精确匹配
            if (h2Text === normalizedAnchor) {
                title = h2Text;
                found = true;
                return false; // 跳出循环
            }
            // 容错匹配：去除所有空格后比较
            const h2NoSpaces = h2Text.replace(/\s+/g, '');
            const anchorNoSpaces = normalizedAnchor.replace(/\s+/g, '');
            if (h2NoSpaces === anchorNoSpaces) {
                title = h2Text;
                found = true;
                return false; // 跳出循环
            }
        });
        
        // 如果没找到匹配的标题，使用第一个 h2（但跳过"目录"）
        if (!found) {
            $h2Elements.each(function() {
                const h2Text = $(this).text().trim();
                if (h2Text !== '目录') {
                    title = h2Text;
                    return false; // 跳出循环
                }
            });
            // 如果所有 h2 都是"目录"，则使用第一个
            if (!title) {
                title = $h2Elements.first().text();
            }
        }
    } 
    // 如果没有 h2 或 anchor，使用第一个 h2
    else {
        title = $h2Elements.first().text() || '未知标题';
    }
    
    $('#dotboxTitle').text(title);
    
    // 更新文档路径
    $('.api-file-path').text(`文档路径: ./${filePath}`);
    
    // 提取并更新描述（h2标题后的第一个段落，跳过"基本信息"标题前的内容）
    let description = '';
    // 找到匹配标题的 h2 元素（如果 title 已确定，查找对应的 h2）
    let $h2 = null;
    if (title) {
        $h2Elements.each(function() {
            if ($(this).text().trim() === title) {
                $h2 = $(this);
                return false; // 跳出循环
            }
        });
    }
    // 如果没找到匹配的 h2，使用第一个 h2
    if (!$h2 || $h2.length === 0) {
        $h2 = $temp.find('h2').first();
    }
    let $next = $h2.next();
    while ($next.length && !$next.is('h3')) {
        if ($next.is('p')) {
            description = $next.text();
            break;
        }
        $next = $next.next();
    }
    $('.api-description').text(description || '');
    
    // 解析基本信息
    parseBasicInfo($temp);
    
    // 解析并填充表格数据
    parseAndFillTables($temp);
    
    // 解析并填充代码示例
    parseAndFillCodeExamples($temp);
    
    // 代码高亮
    if (typeof hljs !== 'undefined') {
        $('.markdown-body pre code').each(function() {
            hljs.highlightElement(this);
        });
    }
    
    // 添加 has-content 类来显示文档内容
    $('#dotboxBody').addClass('has-content');
    
    // 将请求参数表格转换为可编辑状态
    makeTableEditable();
    
    // 初始化调试区
    initDebugArea();
}

// 解析基本信息
function parseBasicInfo($temp) {
    let url = '';
    let method = '';
    let contentType = '';
    let tokenRequired = '';
    
    // 查找"基本信息"标题
    $temp.find('h3').each(function() {
        const title = $(this).text().trim();
        if (title === '基本信息') {
            // 查找后续的列表项
            let $next = $(this).next();
            while ($next.length && !$next.is('h3') && !$next.is('h4')) {
                if ($next.is('ul')) {
                    $next.find('li').each(function() {
                        const text = $(this).text().trim();
                        const $strong = $(this).find('strong');
                        const $code = $(this).find('code');
                        
                        if (text.includes('Url:') || text.includes('URL:')) {
                            url = $code.length ? $code.text() : text.split(':')[1]?.trim() || '';
                        } else if (text.includes('Method:')) {
                            method = $code.length ? $code.text() : text.split(':')[1]?.trim() || '';
                        } else if (text.includes('Content-Type:')) {
                            contentType = $code.length ? $code.text() : text.split(':')[1]?.trim() || '';
                        } else if (text.includes('Token:')) {
                            tokenRequired = text.split(':')[1]?.trim() || '';
                        }
                    });
                    break;
                }
                $next = $next.next();
            }
            return false; // 找到后退出循环
        }
    });
    
    // 更新基本信息显示
    if (url || method || contentType || tokenRequired) {
        $('.api-basic-info .url').text(url);
        $('.api-basic-info .method').text(method);
        $('.api-basic-info .content-type').text(contentType);
        $('.api-basic-info .token-required').text(tokenRequired);
        
        // 根据是否有 Content-Type 显示/隐藏该行
        if (contentType) {
            $('.basic-info-content-type').show();
        } else {
            $('.basic-info-content-type').hide();
        }
        
        $('.api-basic-info').show();
    } else {
        $('.api-basic-info').hide();
    }
}

// 解析并填充表格数据
function parseAndFillTables($temp) {
    // 先隐藏所有区块
    $('.api-changelog').hide();
    $('.api-headers').hide();
    $('.api-query-params').hide();
    $('.api-route-params').hide();
    $('.api-body-params').hide();
    $('.api-response').hide();
    $('.api-error-codes').hide();
    $('#request-object-params-container').empty();
    $('#response-object-params-container').empty();
    
    // 清空所有表格
    $('#changelog-tbody').empty();
    $('#headers-tbody').empty();
    $('#query-params-tbody').empty();
    $('#route-params-tbody').empty();
    $('#body-params-tbody').empty();
    $('#response-tbody').empty();
    $('#error-codes-tbody').empty();
    
    // 查找所有 h3 和 h4 标题
    $temp.find('h3, h4').each(function() {
        const sectionTitle = $(this).text().trim();
        let $table = $(this).next('table');
        
        // 如果紧接着不是表格，尝试查找下一个兄弟元素
        if ($table.length === 0 || !$table.is('table')) {
            let $next = $(this).next();
            while ($next.length && !$next.is('h3') && !$next.is('h4') && !$next.is('h2')) {
                if ($next.is('table')) {
                    $table = $next;
                    break;
                }
                $next = $next.next();
            }
        }
        
        if ($table.length === 0 || !$table.is('table')) return;
        
        // 根据标题判断表格类型
        let $tbody = null;
        let $section = null;
        let isObjectParam = false;
        
        // 更新日志
        if (sectionTitle === '更新日志') {
            $tbody = $('#changelog-tbody');
            $section = $('.api-changelog');
        }
        // HTTP头参数
        else if (sectionTitle === 'HTTP头参数') {
            $tbody = $('#headers-tbody');
            $section = $('.api-headers');
        }
        // 查询参数
        else if (sectionTitle.includes('查询参数') || sectionTitle.includes('Query Parameters')) {
            $tbody = $('#query-params-tbody');
            $section = $('.api-query-params');
        }
        // 路由参数
        else if (sectionTitle === '路由参数') {
            $tbody = $('#route-params-tbody');
            $section = $('.api-route-params');
        }
        // BODY包体参数（请求参数）
        else if (sectionTitle === 'BODY包体参数' && $(this).parent().find('h3:contains("请求参数")').length > 0) {
            $tbody = $('#body-params-tbody');
            $section = $('.api-body-params');
        }
        // 响应参数中的响应体参数
        else if (sectionTitle === '响应体参数' && $(this).parent().find('h3:contains("响应参数")').length > 0) {
            $tbody = $('#response-tbody');
            $section = $('.api-response');
        }
        // 请求OBJECT参数或响应OBJECT参数
        else if (sectionTitle.startsWith('请求OBJECT参数') || sectionTitle.startsWith('响应OBJECT参数')) {
            isObjectParam = true;
            // 创建新的OBJECT参数表格
            // 支持格式：请求OBJECT参数 - {字段名} 或 响应OBJECT参数 - {字段名}
            const isRequestParam = sectionTitle.startsWith('请求OBJECT参数');
            const isResponseParam = sectionTitle.startsWith('响应OBJECT参数');
            const objectName = sectionTitle.replace(/^(请求|响应)OBJECT参数/, '').trim().replace(/^-\s*/, '');
            const $objectSection = $('<div>', { 
                class: 'api-object-params',
                'data-object-name': objectName,
                'data-param-type': isRequestParam ? 'request' : 'response'
            });
            
            // 创建标题和按钮容器
            const $headerContainer = $('<div>', { class: 'object-param-header' });
            const $title = $('<h4>').text(sectionTitle);
            $headerContainer.append($title);
            
            // 只有请求OBJECT参数且父参数为array类型时才显示复制按钮
            // 响应OBJECT参数不显示复制按钮
            if (isRequestParam) {
                const isArrayType = isParentParamArray(objectName);
                if (isArrayType) {
                    const $copyBtn = $('<button>', {
                        class: 'copy-table-btn',
                        text: '➕ 复制表格',
                        'data-object-name': objectName
                    });
                    $copyBtn.on('click', function() {
                        copyObjectTable(objectName);
                    });
                    $headerContainer.append($copyBtn);
                }
            }
            
            $objectSection.append($headerContainer);
            
            // 创建表格容器
            const $tableContainer = $('<div>', { class: 'object-tables-container' });
            
            const $objectTable = $('<table>', { 
                class: 'object-param-table',
                'data-instance': '0'
            });
            const $thead = $('<thead>').html(`
                <tr>
                    <th>参数</th>
                    <th>类型</th>
                    <th>必填</th>
                    <th>描述</th>
                    <th>示例</th>
                </tr>
            `);
            $objectTable.append($thead);
            
            const $objectTbody = $('<tbody>');
            const $rows = $table.find('tbody tr');
            if ($rows.length > 0) {
                $rows.each(function() {
                    const $newRow = $(this).clone();
                    $objectTbody.append($newRow);
                });
            }
            $objectTable.append($objectTbody);
            $tableContainer.append($objectTable);
            $objectSection.append($tableContainer);
            
            // 根据参数类型添加到不同的容器
            if (isRequestParam) {
                $('#request-object-params-container').append($objectSection);
            } else {
                $('#response-object-params-container').append($objectSection);
            }
        }
        // 错误码
        else if (sectionTitle === '错误码') {
            $tbody = $('#error-codes-tbody');
            $section = $('.api-error-codes');
        }
        
        // 填充表格数据
        if ($tbody && $section && !isObjectParam) {
            const $rows = $table.find('tbody tr');
            if ($rows.length > 0) {
                $rows.each(function() {
                    const $newRow = $(this).clone();
                    $tbody.append($newRow);
                });
                $section.show();
            }
        }
    });
}

// 解析并填充代码示例
function parseAndFillCodeExamples($temp) {
    // 先隐藏示例区块
    $('.api-request-example').hide();
    $('.api-response-example').hide();
    $('#request-example-code').text('');
    $('#response-example-container').empty();
    
    let hasRequestExample = false;
    let hasResponseExample = false;
    
    // 查找所有 h3 和 h4 标题
    $temp.find('h3, h4').each(function() {
        const sectionTitle = $(this).text().trim();
        
        // 请求示例
        if (sectionTitle === '请求示例') {
            let $next = $(this).next();
            while ($next.length && !$next.is('h3') && !$next.is('h4') && !$next.is('h2')) {
                if ($next.is('pre')) {
                    const code = $next.find('code').text();
                    $('#request-example-code').text(code);
                    $('.api-request-example').show();
                    hasRequestExample = true;
                    break;
                }
                $next = $next.next();
            }
        }
        // 响应示例
        else if (sectionTitle === '响应示例') {
            let $next = $(this).next();
            const $container = $('#response-example-container');
            
            while ($next.length && !$next.is('h3') && !$next.is('h2')) {
                // 处理 h4 标题（成功响应、失败响应等）
                if ($next.is('h4')) {
                    const subTitle = $next.text().trim();
                    const $subTitleElem = $('<h4>').text(subTitle);
                    $container.append($subTitleElem);
                    
                    // 查找该标题后的代码块
                    let $codeNext = $next.next();
                    while ($codeNext.length && !$codeNext.is('h3') && !$codeNext.is('h4') && !$codeNext.is('h2')) {
                        if ($codeNext.is('pre')) {
                            const $pre = $codeNext.clone();
                            $container.append($pre);
                            hasResponseExample = true;
                            break;
                        }
                        $codeNext = $codeNext.next();
                    }
                }
                // 直接的代码块（没有子标题）
                else if ($next.is('pre')) {
                    const $pre = $next.clone();
                    $container.append($pre);
                    hasResponseExample = true;
                }
                
                $next = $next.next();
            }
            
            if (hasResponseExample) {
                $('.api-response-example').show();
            }
        }
    });
}

// 将请求参数表格转换为可编辑状态
function makeTableEditable() {
    // 只处理请求参数表格：HTTP头参数、查询参数、路由参数、BODY包体参数
    const requestParamSections = [
        '.api-headers',
        '.api-query-params',
        '.api-route-params',
        '.api-body-params'
    ];
    
    requestParamSections.forEach(selector => {
        const $section = $(selector);
        if (!$section.is(':visible')) return;
        
        const $table = $section.find('table');
        if (!$table.length) return;
        
        // 检查表头结构
        const $headerRow = $table.find('thead tr');
        if (!$headerRow.length) return;
        
        const $headerCells = $headerRow.find('th');
        if ($headerCells.length < 5) return;
        
        // 找到"示例"列的索引
        let exampleColIndex = -1;
        $headerCells.each(function(index) {
            if ($(this).text().trim() === '示例') {
                exampleColIndex = index;
                return false;
            }
        });
        
        if (exampleColIndex === -1) return;
        
        // 遍历表格的每一行，将示例列转换为可编辑输入框
        $table.find('tbody tr').each(function() {
            const $row = $(this);
            const $cells = $row.find('td');
            
            if ($cells.length <= exampleColIndex) return;
            
            const paramName = $cells.eq(0).text().trim();
            const $exampleCell = $cells.eq(exampleColIndex);
            
            // 检查是否已经是输入框
            if ($exampleCell.find('input').length) {
                // 如果已经是输入框，确保绑定了事件监听
                const $existingInput = $exampleCell.find('input');
                $existingInput.off('input').on('input', function() {
                    syncParamsToDebugArea();
                });
                return;
            }
            
            let originalValue = $exampleCell.text().trim();
            
            // 特殊处理：Token 参数的占位符替换（仅限HTTP头参数）
            if (selector === '.api-headers' && paramName.toLowerCase() === 'token' && (!originalValue || originalValue === '{token}')) {
                originalValue = '123456';
            }
            
            // 将示例单元格转换为输入框
            $exampleCell.addClass('editable-cell');
            const $input = $('<input>', {
                type: 'text',
                class: 'editable-cell-input',
                'data-param-name': paramName,
                'data-section': selector.replace('.api-', '').replace('-', '_'),
                value: originalValue,
                placeholder: '请输入示例值'
            });
            
            // 添加实时同步事件监听
            $input.on('input', function() {
                syncParamsToDebugArea();
            });
            
            $exampleCell.empty().append($input);
        });
    });
    
    // 同样处理 OBJECT 参数表格（只处理请求OBJECT参数，响应OBJECT参数保持不可编辑）
    $('#request-object-params-container .api-object-params').each(function() {
        const $section = $(this);
        const paramType = $section.attr('data-param-type');
        
        // 只处理请求OBJECT参数，响应OBJECT参数跳过
        if (paramType !== 'request') return;
        
        const $table = $section.find('table');
        if (!$table.length) return;
        
        // 检查表头结构
        const $headerRow = $table.find('thead tr');
        if (!$headerRow.length) return;
        
        const $headerCells = $headerRow.find('th');
        if ($headerCells.length < 5) return;
        
        // 找到"示例"列的索引
        let exampleColIndex = -1;
        $headerCells.each(function(index) {
            if ($(this).text().trim() === '示例') {
                exampleColIndex = index;
                return false;
            }
        });
        
        if (exampleColIndex === -1) return;
        
        // 只对请求OBJECT参数表格进行可编辑处理
        $table.find('tbody tr').each(function() {
            const $row = $(this);
            const $cells = $row.find('td');
            
            if ($cells.length <= exampleColIndex) return;
            
            const paramName = $cells.eq(0).text().trim();
            const $exampleCell = $cells.eq(exampleColIndex);
            
            // 检查是否已经是输入框
            if ($exampleCell.find('input').length) {
                // 如果已经是输入框，确保绑定了事件监听
                const $existingInput = $exampleCell.find('input');
                $existingInput.off('input').on('input', function() {
                    syncParamsToDebugArea();
                });
                return;
            }
            
            let originalValue = $exampleCell.text().trim();
            
            $exampleCell.addClass('editable-cell');
            const $input = $('<input>', {
                type: 'text',
                class: 'editable-cell-input',
                'data-param-name': paramName,
                value: originalValue,
                placeholder: '请输入示例值'
            });
            
            // 添加实时同步事件监听
            $input.on('input', function() {
                syncParamsToDebugArea();
            });
            
            $exampleCell.empty().append($input);
        });
    });
}

// 初始化调试区
function initDebugArea() {
    // 显示调试区主内容
    $('#debugEmptyPlaceholder').hide();
    $('#debugMain').show();
    
    // 获取文档区的基本信息
    const url = $('.api-basic-info .url').text();
    const method = $('.api-basic-info .method').text();
    
    // 更新基本信息显示
    updateDebugBasicInfo(method, url);
    
    // 更新请求头参数（直接从文档区HTTP头参数表格读取）
    updateDebugHeaders();
    
    // 更新请求参数
    updateDebugParams(method);
    
    // 清空响应结果
    clearDebugResponse();
}

// 更新调试区基本信息
function updateDebugBasicInfo(method, url) {
    // 处理路由参数：将URL中的 {参数名} 替换为实际值
    let processedUrl = url;
    const routeParams = getRouteParamsFromTable();
    
    // 替换URL中的所有路由参数占位符
    for (const paramName in routeParams) {
        const placeholder = `{${paramName}}`;
        if (processedUrl.includes(placeholder)) {
            processedUrl = processedUrl.replace(placeholder, routeParams[paramName]);
        }
    }
    
    const $basicUrl = $('#debugBasicUrl');
    const methodClass = method.toUpperCase();
    $basicUrl.html(`<span class="method ${methodClass}">${method}</span> ${processedUrl}`);
    
    // 保存处理后的URL供发送请求时使用
    $basicUrl.attr('data-url', processedUrl);
}

// 更新调试区请求头参数
function updateDebugHeaders() {
    const $tbody = $('#debugHeadersTbody');
    $tbody.empty();
    
    // 从文档区HTTP头参数表格读取所有参数
    $('#headers-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 5) {
            // 读取参数名（保持原样，如Token首字母大写）
            const paramName = $cells.eq(0).text().trim();
            
            // 读取示例值
            const $input = $cells.eq(4).find('input.editable-cell-input');
            let paramValue = '';
            if ($input.length) {
                paramValue = $input.val();
            } else {
                paramValue = $cells.eq(4).text().trim();
            }
            
            // 创建调试区的参数行
            const $row = $('<tr>');
            $row.append($('<td>').text(paramName));
            $row.append($('<td>').html(`<input type="text" class="debug-input" data-header-name="${paramName}" value="${paramValue}" placeholder="请输入${paramName}...">`));
            $tbody.append($row);
        }
    });
    
    // 如果没有任何请求头，隐藏整个section
    if ($tbody.children().length === 0) {
        $('.debug-headers').hide();
    } else {
        $('.debug-headers').show();
    }
}

// 更新调试区请求参数
function updateDebugParams(method) {
    const $editor = $('#debugParamsEditor');
    
    // 根据请求方法决定参数类型
    if (method && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
        // POST等请求：使用BODY参数
        $('#debugParamsTitle').text('请求参数 (Body)');
        
        // 直接调用同步函数，从表格生成参数（支持object和array类型）
        syncBodyParamsToDebug();
        
        $('.debug-params').show();
    } else {
        // GET等请求：使用Query参数（URL查询字符串格式）
        $('#debugParamsTitle').text('请求参数 (Query)');
        
        // 从查询参数表格生成
        const queryParams = generateQueryParamsFromTable();
        if (Object.keys(queryParams).length > 0) {
            // 转换为URL查询字符串格式
            const queryString = buildQueryString(queryParams);
            $editor.val(queryString);
            $('.debug-params').show();
        } else {
            $('.debug-params').hide();
        }
    }
}

// 从BODY参数表格生成JSON对象
function generateBodyParamsFromTable() {
    const params = {};
    $('#body-params-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 5) {
            const paramName = $cells.eq(0).text().trim();
            const $input = $cells.eq(4).find('input.editable-cell-input');
            let value = '';
            
            if ($input.length) {
                value = $input.val();
            } else {
                value = $cells.eq(4).text().trim();
            }
            
            // 尝试转换类型
            const type = $cells.eq(1).text().trim().toLowerCase();
            if (type.includes('int') || type.includes('number')) {
                params[paramName] = value ? parseInt(value) || 0 : 0;
            } else if (type.includes('bool')) {
                params[paramName] = value === 'true' || value === '1';
            } else {
                params[paramName] = value;
            }
        }
    });
    return params;
}

// 从查询参数表格生成对象
function generateQueryParamsFromTable() {
    const params = {};
    $('#query-params-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 5) {
            const paramName = $cells.eq(0).text().trim();
            const $input = $cells.eq(4).find('input.editable-cell-input');
            let value = '';
            
            if ($input.length) {
                value = $input.val();
            } else {
                value = $cells.eq(4).text().trim();
            }
            
            params[paramName] = value;
        }
    });
    return params;
}

// 将参数对象转换为URL查询字符串
function buildQueryString(params) {
    const queryParts = [];
    for (const key in params) {
        if (params.hasOwnProperty(key)) {
            const value = params[key];
            if (value !== '' && value !== null && value !== undefined) {
                queryParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
            }
        }
    }
    return queryParts.join('&');
}

// 从路由参数表格获取参数值
function getRouteParamsFromTable() {
    const params = {};
    $('#route-params-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 5) {
            const paramName = $cells.eq(0).text().trim();
            const $input = $cells.eq(4).find('input.editable-cell-input');
            let value = '';
            
            if ($input.length) {
                value = $input.val();
            } else {
                value = $cells.eq(4).text().trim();
            }
            
            params[paramName] = value;
        }
    });
    return params;
}

// 清空响应结果
function clearDebugResponse() {
    $('#debugResponseTime').hide();
    $('#debugResponseStatus').hide();
    $('#debugResponseHeadersContainer').hide();
    $('#debugResponseBodyContainer').hide();
    $('#debugEmptyState').show();
}

// ==================== 参数实时同步功能 ====================

// 参数同步主函数
function syncParamsToDebugArea() {
    // 同步HTTP头参数
    syncHeadersToDebug();
    
    // 同步路由参数并更新URL
    syncRouteParamsToDebug();
    
    // 根据请求方法同步不同的参数
    const method = $('.api-basic-info .method').text().trim();
    if (method && ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase())) {
        // POST等请求：同步BODY参数
        syncBodyParamsToDebug();
    } else {
        // GET等请求：同步查询参数
        syncQueryParamsToDebug();
    }
}

// 同步HTTP头参数到调试区
function syncHeadersToDebug() {
    // 遍历文档区的HTTP头参数
    $('#headers-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 5) {
            const paramName = $cells.eq(0).text().trim();
            const $input = $cells.eq(4).find('input.editable-cell-input');
            
            if ($input.length) {
                const value = $input.val();
                
                // 更新调试区对应的请求头输入框
                $('#debugHeadersTbody tr').each(function() {
                    const $debugCells = $(this).find('td');
                    const debugParamName = $debugCells.eq(0).text().trim();
                    
                    if (debugParamName.toLowerCase() === paramName.toLowerCase()) {
                        const $debugInput = $debugCells.eq(1).find('input');
                        if ($debugInput.length) {
                            $debugInput.val(value);
                        }
                    }
                });
            }
        }
    });
}

// 同步查询参数到调试区
function syncQueryParamsToDebug() {
    const queryParams = {};
    
    // 从文档区获取查询参数
    $('#query-params-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 5) {
            const paramName = $cells.eq(0).text().trim();
            const $input = $cells.eq(4).find('input.editable-cell-input');
            
            if ($input.length) {
                const value = $input.val();
                if (value) {
                    queryParams[paramName] = value;
                }
            }
        }
    });
    
    // 转换为查询字符串并更新调试区
    const queryString = buildQueryString(queryParams);
    $('#debugParamsEditor').val(queryString);
}

// 同步路由参数并更新URL
function syncRouteParamsToDebug() {
    const url = $('.api-basic-info .url').text().trim();
    const method = $('.api-basic-info .method').text().trim();
    
    // 处理路由参数：将URL中的 {参数名} 替换为实际值
    let processedUrl = url;
    const routeParams = getRouteParamsFromTable();
    
    // 替换URL中的所有路由参数占位符
    for (const paramName in routeParams) {
        const placeholder = `{${paramName}}`;
        if (processedUrl.includes(placeholder)) {
            processedUrl = processedUrl.replace(placeholder, routeParams[paramName]);
        }
    }
    
    // 更新调试区的URL显示
    const $basicUrl = $('#debugBasicUrl');
    const methodClass = method.toUpperCase();
    $basicUrl.html(`<span class="method ${methodClass}">${method}</span> ${processedUrl}`);
    $basicUrl.attr('data-url', processedUrl);
}

// 构建BODY参数对象
function buildBodyParamsPayload() {
    const bodyParams = {};
    
    $('#body-params-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 5) {
            const paramName = $cells.eq(0).text().trim();
            const paramType = $cells.eq(1).text().trim().toLowerCase();
            const $input = $cells.eq(4).find('input.editable-cell-input');
            
            let value = '';
            if ($input.length) {
                value = $input.val();
            } else {
                value = $cells.eq(4).text().trim();
            }
            
            if (paramType === 'object') {
                bodyParams[paramName] = buildObjectParam(paramName);
            } else if (paramType === 'array') {
                bodyParams[paramName] = buildArrayParam(paramName);
            } else {
                if (paramType.includes('int') || paramType.includes('number')) {
                    const numValue = parseInt(value);
                    bodyParams[paramName] = isNaN(numValue) ? 0 : numValue;
                } else if (paramType.includes('bool')) {
                    bodyParams[paramName] = value === 'true' || value === '1';
                } else {
                    bodyParams[paramName] = value;
                }
            }
        }
    });
    
    return bodyParams;
}

// 同步BODY参数到调试区
function syncBodyParamsToDebug() {
    const bodyParams = buildBodyParamsPayload();
    const jsonString = JSON.stringify(bodyParams, null, 2);
    $('#debugParamsEditor').val(jsonString);
}

// 构建object类型参数
function buildObjectParam(objectName) {
    const obj = {};
    
    // 查找对应的请求OBJECT参数表格
    $('#request-object-params-container .api-object-params').each(function() {
        const $section = $(this);
        const sectionTitle = $section.find('h4').text().trim();
        
        // 检查标题是否匹配（例如 "请求OBJECT参数 - Records" 匹配 "Records"）
        // 只匹配请求OBJECT参数，不匹配响应OBJECT参数
        if (sectionTitle.startsWith('请求OBJECT参数') && sectionTitle.includes(objectName)) {
            // 获取第一个表格实例的数据
            const $tables = $section.find('table');
            if ($tables.length > 0) {
                const $firstTable = $tables.first();
                $firstTable.find('tbody tr').each(function() {
                    const $cells = $(this).find('td');
                    if ($cells.length >= 5) {
                        const fieldName = $cells.eq(0).text().trim();
                        const fieldType = $cells.eq(1).text().trim().toLowerCase();
                        const $input = $cells.eq(4).find('input.editable-cell-input');
                        
                        let value = '';
                        if ($input.length) {
                            value = $input.val();
                        } else {
                            value = $cells.eq(4).text().trim();
                        }
                        
                        // 类型转换
                        if (fieldType.includes('int') || fieldType.includes('number')) {
                            obj[fieldName] = value ? parseInt(value) || 0 : 0;
                        } else if (fieldType.includes('bool')) {
                            obj[fieldName] = value === 'true' || value === '1';
                        } else {
                            obj[fieldName] = value;
                        }
                    }
                });
            }
        }
    });
    
    return obj;
}

// 构建array类型参数
function buildArrayParam(arrayName) {
    const arr = [];
    
    // 查找对应的请求OBJECT参数表格
    $('#request-object-params-container .api-object-params').each(function() {
        const $section = $(this);
        const sectionTitle = $section.find('h4').text().trim();
        
        // 检查标题是否匹配（只匹配请求OBJECT参数，不匹配响应OBJECT参数）
        if (sectionTitle.startsWith('请求OBJECT参数') && sectionTitle.includes(arrayName)) {
            // 获取所有表格实例（支持复制表格功能）
            const $tables = $section.find('table');
            $tables.each(function() {
                const obj = {};
                $(this).find('tbody tr').each(function() {
                    const $cells = $(this).find('td');
                    if ($cells.length >= 5) {
                        const fieldName = $cells.eq(0).text().trim();
                        const fieldType = $cells.eq(1).text().trim().toLowerCase();
                        const $input = $cells.eq(4).find('input.editable-cell-input');
                        
                        let value = '';
                        if ($input.length) {
                            value = $input.val();
                        } else {
                            value = $cells.eq(4).text().trim();
                        }
                        
                        // 类型转换
                        if (fieldType.includes('int') || fieldType.includes('number')) {
                            obj[fieldName] = value ? parseInt(value) || 0 : 0;
                        } else if (fieldType.includes('bool')) {
                            obj[fieldName] = value === 'true' || value === '1';
                        } else {
                            obj[fieldName] = value;
                        }
                    }
                });
                
                // 只有当对象有属性时才添加到数组
                if (Object.keys(obj).length > 0) {
                    arr.push(obj);
                }
            });
        }
    });
    
    return arr;
}

// ==================== 复制表格功能 ====================

// 检查父参数是否为array类型
function isParentParamArray(objectName) {
    let isArray = false;
    
    // 在BODY参数表格中查找
    $('#body-params-tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 2) {
            const paramName = $cells.eq(0).text().trim();
            const paramType = $cells.eq(1).text().trim().toLowerCase();
            
            if (paramName === objectName && paramType === 'array') {
                isArray = true;
                return false; // 跳出循环
            }
        }
    });
    
    // 也在响应参数表格中查找
    if (!isArray) {
        $('#response-tbody tr').each(function() {
            const $cells = $(this).find('td');
            if ($cells.length >= 2) {
                const paramName = $cells.eq(0).text().trim();
                const paramType = $cells.eq(1).text().trim().toLowerCase();
                
                if (paramName === objectName && paramType === 'array') {
                    isArray = true;
                    return false; // 跳出循环
                }
            }
        });
    }
    
    return isArray;
}

// 复制OBJECT参数表格
function copyObjectTable(objectName) {
    // 查找对应的OBJECT参数section
    const $section = $(`.api-object-params[data-object-name="${objectName}"]`);
    if (!$section.length) return;
    
    const $tableContainer = $section.find('.object-tables-container');
    const $existingTables = $tableContainer.find('table');
    const newInstance = $existingTables.length;
    
    // 克隆第一个表格
    const $firstTable = $existingTables.first();
    const $newTable = $firstTable.clone(true);
    
    // 更新实例编号
    $newTable.attr('data-instance', newInstance);
    
    // 创建表格包装器，包含删除按钮
    const $tableWrapper = $('<div>', { 
        class: 'object-table-wrapper',
        'data-instance': newInstance
    });
    
    // 添加实例标题和删除按钮
    const $instanceHeader = $('<div>', { class: 'table-instance-header' });
    const $instanceLabel = $('<span>', { 
        class: 'table-instance-number',
        text: `${objectName}[${newInstance}]`
    });
    const $deleteBtn = $('<button>', {
        class: 'delete-table-btn',
        text: '🗑️ 删除',
        'data-instance': newInstance
    });
    
    $deleteBtn.on('click', function() {
        deleteObjectTable(objectName, newInstance);
    });
    
    $instanceHeader.append($instanceLabel);
    $instanceHeader.append($deleteBtn);
    $tableWrapper.append($instanceHeader);
    $tableWrapper.append($newTable);
    
    // 将示例单元格转换为可编辑输入框
    makeTableInstanceEditable($newTable);
    
    // 添加到容器
    $tableContainer.append($tableWrapper);
    
    // 触发同步更新
    syncParamsToDebugArea();
}

// 删除OBJECT参数表格实例
function deleteObjectTable(objectName, instance) {
    const $section = $(`.api-object-params[data-object-name="${objectName}"]`);
    if (!$section.length) return;
    
    // 删除指定实例的包装器
    $section.find(`.object-table-wrapper[data-instance="${instance}"]`).remove();
    
    // 重新编号剩余的表格实例
    const $tableContainer = $section.find('.object-tables-container');
    const $wrappers = $tableContainer.find('.object-table-wrapper');
    
    $wrappers.each(function(index) {
        $(this).attr('data-instance', index + 1);
        $(this).find('table').attr('data-instance', index + 1);
        $(this).find('.table-instance-number').text(`${objectName}[${index + 1}]`);
        $(this).find('.delete-table-btn').attr('data-instance', index + 1);
    });
    
    // 触发同步更新
    syncParamsToDebugArea();
}

// 将表格实例转换为可编辑状态
function makeTableInstanceEditable($table) {
    // 找到示例列的索引
    const $headerCells = $table.find('thead th');
    let exampleColIndex = -1;
    
    $headerCells.each(function(index) {
        if ($(this).text().trim() === '示例') {
            exampleColIndex = index;
            return false;
        }
    });
    
    if (exampleColIndex === -1) return;
    
    // 将每一行的示例列转换为输入框
    $table.find('tbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length <= exampleColIndex) return;
        
        const paramName = $cells.eq(0).text().trim();
        const $exampleCell = $cells.eq(exampleColIndex);
        
        // 如果已经是输入框，跳过
        if ($exampleCell.find('input').length) {
            // 为已存在的输入框添加事件监听
            $exampleCell.find('input').on('input', function() {
                syncParamsToDebugArea();
            });
            return;
        }
        
        let originalValue = $exampleCell.text().trim();
        
        $exampleCell.addClass('editable-cell');
        const $input = $('<input>', {
            type: 'text',
            class: 'editable-cell-input',
            'data-param-name': paramName,
            value: originalValue,
            placeholder: '请输入示例值'
        });
        
        // 添加实时同步事件监听
        $input.on('input', function() {
            syncParamsToDebugArea();
        });
        
        $exampleCell.empty().append($input);
    });
}

// ==================== 发送请求功能 ====================

// 初始化发送请求按钮事件
$(document).ready(function() {
    $('#debugSendBtn').on('click', function() {
        sendApiRequest();
    });
});

// 发送API请求主函数
async function sendApiRequest() {
    const $btn = $('#debugSendBtn');
    
    // 收集请求配置
    const config = collectRequestConfig();
    if (!config) {
        alert('请求配置错误，请检查参数');
        return;
    }
    
    // 设置按钮loading状态
    setButtonLoading($btn, true);
    
    // 记录开始时间
    const startTime = Date.now();
    
    try {
        // 发送请求
        const result = await $.ajax({
            url: config.url,
            method: config.method,
            headers: config.headers,
            data: config.data,
            contentType: config.contentType,
            processData: config.processData,
            dataType: 'json',
            // 完整的响应信息，包括状态码和响应头
            complete: function(jqXHR) {
                const endTime = Date.now();
                const duration = endTime - startTime;
                
                if (jqXHR.status >= 200 && jqXHR.status < 300) {
                    handleRequestSuccess(jqXHR, duration);
                } else {
                    handleRequestError(jqXHR, duration);
                }
                
                // 恢复按钮状态
                setButtonLoading($btn, false);
            }
        });
    } catch (error) {
        const endTime = Date.now();
        const duration = endTime - startTime;
        handleRequestError(error, duration);
        setButtonLoading($btn, false);
    }
}

// 收集请求配置
function collectRequestConfig() {
    // 获取基本信息
    const $basicUrl = $('#debugBasicUrl');
    const url = $basicUrl.attr('data-url') || $basicUrl.text().replace(/^(GET|POST|PUT|DELETE|PATCH)\s+/, '').trim();
    const methodMatch = $basicUrl.text().match(/^(GET|POST|PUT|DELETE|PATCH)/);
    const method = methodMatch ? methodMatch[1] : 'GET';
    
    if (!url) {
        alert('无法获取请求URL');
        return null;
    }
    
    // 拼接完整URL（使用当前域名作为基础URL）
    const baseUrl = window.location.origin;
    const fullUrl = url.startsWith('http') ? url : baseUrl + url;
    
    // 收集请求头
    const headers = {};
    $('#debugHeadersTbody tr').each(function() {
        const $cells = $(this).find('td');
        if ($cells.length >= 2) {
            const headerName = $cells.eq(0).text().trim();
            const $input = $cells.eq(1).find('input');
            const headerValue = $input.length ? $input.val().trim() : '';
            
            if (headerName && headerValue) {
                headers[headerName] = headerValue;
            }
        }
    });
    
    // 处理请求参数
    let finalUrl = fullUrl;
    let data = null;
    const preferredContentType = getPreferredContentType(headers);
    const normalizedContentType = preferredContentType ? preferredContentType.split(';')[0].trim().toLowerCase() : '';
    let contentType = preferredContentType || 'application/json; charset=UTF-8';
    let processData = false;
    
    let paramsText = $('#debugParamsEditor').val().trim();
    const upperMethod = method.toUpperCase();
    
    if (['POST', 'PUT', 'PATCH'].includes(upperMethod)) {
        if (!paramsText) {
            const fallbackJson = JSON.stringify(buildBodyParamsPayload(), null, 2);
            if (fallbackJson) {
                $('#debugParamsEditor').val(fallbackJson);
                paramsText = fallbackJson;
            }
        }
        
        if (!paramsText) {
            alert('请求参数为空，请在BODY参数表或调试器中填写示例后重试。');
            console.warn('调试请求缺少Body参数，已终止发送。');
            return null;
        }
        
        if (normalizedContentType === 'application/x-www-form-urlencoded') {
            try {
                data = buildFormBodyFromJson(paramsText);
                contentType = 'application/x-www-form-urlencoded; charset=UTF-8';
                processData = false;
            } catch (e) {
                alert(e.message);
                return null;
            }
        } else if (normalizedContentType === 'multipart/form-data') {
            try {
                data = buildFormDataFromJson(paramsText);
                contentType = false; // 让浏览器自动设置 multipart boundary
                processData = false;
            } catch (e) {
                alert(e.message);
                return null;
            }
        } else {
            try {
                const jsonData = JSON.parse(paramsText);
                data = JSON.stringify(jsonData);
                contentType = preferredContentType || 'application/json; charset=UTF-8';
                processData = false;
            } catch (e) {
                alert('请求参数格式错误，请检查JSON格式: ' + e.message);
                return null;
            }
        }
    } else {
        // GET等请求：将查询字符串拼接到URL
        if (paramsText) {
            const separator = finalUrl.includes('?') ? '&' : '?';
            finalUrl = finalUrl + separator + paramsText;
        }
    }
    
    return {
        url: finalUrl,
        method: method,
        headers: headers,
        data: data,
        contentType: contentType,
        processData: processData
    };
}

// 获取优先的 Content-Type
function getPreferredContentType(headers) {
    let headerContentType = '';
    Object.keys(headers).forEach(key => {
        if (key.toLowerCase() === 'content-type' && !headerContentType) {
            headerContentType = headers[key];
        }
    });
    
    if (headerContentType) {
        return headerContentType;
    }
    
    const basicInfoContentType = $('.api-basic-info .content-type').text().trim();
    return basicInfoContentType || '';
}

// 将 JSON 文本转换为 x-www-form-urlencoded 字符串
function buildFormBodyFromJson(paramsText) {
    const parsed = parseJsonParams(paramsText);
    const entries = buildFormEntries(parsed);
    if (entries.length === 0) {
        return '';
    }
    
    const searchParams = new URLSearchParams();
    entries.forEach(([key, value]) => {
        searchParams.append(key, value);
    });
    
    return searchParams.toString();
}

// 将 JSON 文本转换为 multipart/form-data 对象
function buildFormDataFromJson(paramsText) {
    const parsed = parseJsonParams(paramsText);
    const entries = buildFormEntries(parsed);
    const formData = new FormData();
    
    entries.forEach(([key, value]) => {
        formData.append(key, value);
    });
    
    return formData;
}

// 解析 JSON 文本
function parseJsonParams(paramsText) {
    if (!paramsText) {
        throw new Error('请求参数为空，无法构建表单数据');
    }
    
    let parsed;
    try {
        parsed = JSON.parse(paramsText);
    } catch (error) {
        throw new Error('请求参数格式错误，请输入合法的 JSON：' + error.message);
    }
    
    if (parsed === null || typeof parsed !== 'object') {
        throw new Error('请求参数需为对象或数组，无法转换为表单数据');
    }
    
    return parsed;
}

// 将对象打平成键值对
function buildFormEntries(value, prefix = '', entries = []) {
    if (value === null || value === undefined) {
        if (prefix) entries.push([prefix, '']);
        return entries;
    }
    
    if (Array.isArray(value)) {
        value.forEach((item, index) => {
            const key = prefix ? `${prefix}[${index}]` : `${index}`;
            buildFormEntries(item, key, entries);
        });
        return entries;
    }
    
    if (typeof value === 'object') {
        Object.keys(value).forEach(childKey => {
            const key = prefix ? `${prefix}[${childKey}]` : childKey;
            buildFormEntries(value[childKey], key, entries);
        });
        return entries;
    }
    
    if (prefix) {
        entries.push([prefix, normalizeFormValue(value)]);
    }
    
    return entries;
}

function normalizeFormValue(value) {
    if (value === null || value === undefined) return '';
    if (typeof value === 'boolean') return value ? 'true' : 'false';
    return String(value);
}

// 处理请求成功
function handleRequestSuccess(jqXHR, duration) {
    // 隐藏空状态
    $('#debugEmptyState').hide();
    
    // 显示状态码
    const statusCode = jqXHR.status;
    const statusText = jqXHR.statusText || 'OK';
    $('#debugStatusCode').text(statusCode).removeClass('status-error').addClass('status-success');
    $('#debugStatusText').text(statusText);
    $('#debugResponseStatus').show();
    
    // 显示请求耗时
    $('#debugResponseTime').text(`(${duration}ms)`).show();
    
    // 格式化并显示响应头
    const responseHeaders = formatResponseHeaders(jqXHR);
    $('#debugResponseHeaders').text(responseHeaders);
    $('#debugResponseHeadersContainer').show();
    
    // 显示响应体
    let responseBody = jqXHR.responseText;
    try {
        // 尝试格式化JSON
        const jsonData = JSON.parse(responseBody);
        responseBody = JSON.stringify(jsonData, null, 2);
    } catch (e) {
        // 如果不是JSON，保持原样
    }
    
    $('#debugResponseBody').text(responseBody);
    
    // 代码高亮
    if (typeof hljs !== 'undefined') {
        hljs.highlightElement($('#debugResponseBody')[0]);
    }
    
    $('#debugResponseBodyContainer').show();
}

// 处理请求失败
function handleRequestError(jqXHR, duration) {
    // 隐藏空状态
    $('#debugEmptyState').hide();
    
    // 显示状态码
    const statusCode = jqXHR.status || 0;
    const statusText = jqXHR.statusText || 'Error';
    $('#debugStatusCode').text(statusCode || '网络错误').removeClass('status-success').addClass('status-error');
    $('#debugStatusText').text(statusText);
    $('#debugResponseStatus').show();
    
    // 显示请求耗时
    $('#debugResponseTime').text(`(${duration}ms)`).show();
    
    // 格式化并显示响应头
    if (jqXHR.getAllResponseHeaders) {
        const responseHeaders = formatResponseHeaders(jqXHR);
        $('#debugResponseHeaders').text(responseHeaders);
        $('#debugResponseHeadersContainer').show();
    }
    
    // 显示错误响应体
    let responseBody = '';
    if (jqXHR.responseText) {
        responseBody = jqXHR.responseText;
        try {
            // 尝试格式化JSON错误响应
            const jsonData = JSON.parse(responseBody);
            responseBody = JSON.stringify(jsonData, null, 2);
        } catch (e) {
            // 如果不是JSON，保持原样
        }
    } else if (jqXHR.statusText) {
        responseBody = jqXHR.statusText;
    } else {
        responseBody = '请求失败，无响应数据';
    }
    
    $('#debugResponseBody').text(responseBody);
    
    // 代码高亮
    if (typeof hljs !== 'undefined') {
        hljs.highlightElement($('#debugResponseBody')[0]);
    }
    
    $('#debugResponseBodyContainer').show();
}

// 格式化响应头
function formatResponseHeaders(jqXHR) {
    const headersString = jqXHR.getAllResponseHeaders();
    if (!headersString) return '无响应头信息';
    
    // 将响应头字符串转换为更易读的格式
    const headers = headersString.trim().split('\n');
    return headers.map(h => h.trim()).filter(h => h).join('\n');
}

// 设置按钮loading状态
function setButtonLoading($btn, isLoading) {
    if (isLoading) {
        $btn.prop('disabled', true);
        $btn.find('.btn-icon').html('⏳');
        $btn.find('.btn-text').text('发送中...');
    } else {
        resetButton($btn);
    }
}

// 恢复按钮初始状态
function resetButton($btn) {
    $btn.prop('disabled', false);
    $btn.find('.btn-icon').html('▶');
    $btn.find('.btn-text').text('发送请求');
}

// 切换响应头显示/隐藏
function toggleDebugResponseHeaders() {
    const $content = $('#debugResponseHeadersContent');
    const $icon = $('#debugResponseHeadersIcon');
    
    if ($content.is(':visible')) {
        $content.slideUp(200);
        $icon.text('▶');
    } else {
        $content.slideDown(200);
        $icon.text('▼');
    }
}

